package cn.flying.cloud.base.common.utils.lang;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Locale;

/**
 * 字符串处理工具类
 *
 * @author: admin
 * @date: 2022年04月02日 21:43
 * @version: 1.0
 */
public class StringUtil extends org.apache.commons.lang3.StringUtils {
    public StringUtil() {
    }

    /***
     * 下划线命名转为驼峰命名
     * @param str
     */
    public static String underlineToHump(String str) {
        // 空值处理
        if (str == null) {
            str = "";
        }
        StringBuilder result = new StringBuilder();
        String[] splits = str.split("_");
        for (String s : splits) {
            if (result.length() == 0) {
                result.append(s.toLowerCase());
            } else {
                result.append(s.substring(0, 1).toUpperCase());
                result.append(s.substring(1).toLowerCase());
            }
        }
        return result.toString();
    }

    /**
     * 驼峰转下划线
     *
     * @param str
     * @return
     */
    public static String humpToUnderline(String str) {
        // 空值处理
        if (str == null) {
            str = "";
        }
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < str.length(); ++i) {
            if (str.charAt(i) >= 'A' && str.charAt(i) <= 'Z') {
                stringBuilder.append("_").append(str.charAt(i));
            } else {
                stringBuilder.append(str.charAt(i));
            }
        }
        return stringBuilder.toString().toLowerCase();
    }

    /***
     * 下划线命名转为首字母大写
     * @param str
     */
    public static String underlineToHeadUpper(String str) {
        // 空值处理
        if (str == null) {
            str = "";
        }
        StringBuilder result = new StringBuilder();
        String[] splits = str.split("_");
        for (String s : splits) {
            result.append(s.substring(0, 1).toUpperCase());
            result.append(s.substring(1).toLowerCase());
        }
        return result.toString();
    }

    /**
     * 首字母大写转下划线
     *
     * @param str
     * @return
     */
    public static String headUpperToUnderline(String str) {
        // 空值处理
        if (str == null) {
            str = "";
        }
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < str.length(); ++i) {
            if (str.charAt(i) >= 'A' && str.charAt(i) <= 'Z') {
                if (i == 0) {
                    stringBuilder.append(str.charAt(i));
                } else {
                    stringBuilder.append("_").append(str.charAt(i));
                }
            } else {
                stringBuilder.append(str.charAt(i));
            }
        }
        return stringBuilder.toString().toLowerCase();
    }

    /**
     * 左侧填充字符0
     *
     * @param str    原字符串
     * @param length 长度
     * @return
     */
    public static String leftPad(String str, int length) {
        return leftPad(str, '0', length);
    }

    /**
     * 左侧填充指定字符
     *
     * @param str    原字符串
     * @param c      填充字符
     * @param length 长度
     * @return
     */
    public static String leftPad(String str, char c, int length) {
        // 空值处理
        if (str == null) {
            str = "";
        }
        int strLen = str.length();
        // 如果已达到或超过目标长度，直接返回
        if (strLen >= length) {
            return str;
        }
        // 计算需要填充的字符数量
        int padLength = length - strLen;
        // 创建一个字符数组用于填充
        char[] padding = new char[padLength];
        // 填充指定字符
        Arrays.fill(padding, c);

        // 拼接填充字符和原始字符串
        return new String(padding) + str;
    }

    /**
     * 右侧填充字符0
     *
     * @param str    原字符串
     * @param length 长度
     * @return
     */
    public static String rightPad(String str, int length) {
        return rightPad(str, '0', length);
    }

    /**
     * 右侧填充指定字符
     *
     * @param str    原字符串
     * @param c      填充字符
     * @param length 长度
     * @return
     */
    public static String rightPad(String str, char c, int length) {
        // 处理null值，视为空字符串
        if (str == null) {
            str = "";
        }

        int strLen = str.length();
        // 如果已达到或超过目标长度，直接返回
        if (strLen >= length) {
            return str;
        }

        // 计算需要填充的字符数量
        int padLength = length - strLen;
        // 创建填充字符数组
        char[] padding = new char[padLength];
        Arrays.fill(padding, c);

        // 拼接原始字符串和填充字符
        return str + new String(padding);
    }

    /**
     * List 转 Array
     *
     * @param list
     * @return
     */
    public static String[] toStringArr(List<String> list) {
        String[] result = new String[list.size()];
        for (int i = 0; i < list.size(); ++i) {
            result[i] = list.get(i);
        }
        return result;
    }

    /**
     * Array 转List
     *
     * @param strings
     * @return
     */
    public static List<String> toStringList(String[] strings) {
        if (strings == null) {
            return new ArrayList<>();
        } else {
            List<String> list = new ArrayList<>();
            Collections.addAll(list, strings);
            return list;
        }
    }

    /**
     * 将byte数组转换为十六进制字符串
     *
     * @param bytes 要转换的byte数组
     * @return 转换后的十六进制字符串，null或空数组返回空字符串
     */
    public static String bytesToHex(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return "";
        }

        // 每个字节需要两个十六进制字符
        StringBuilder sb = new StringBuilder(bytes.length * 2);
        char[] hexDigits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

        for (byte b : bytes) {
            // 高4位转换
            sb.append(hexDigits[(b >>> 4) & 0x0f]);
            // 低4位转换
            sb.append(hexDigits[b & 0x0f]);
        }

        return sb.toString();
    }

    /**
     * 将十六进制字符串转换为byte数组
     *
     * @param hexString 十六进制字符串，可以包含大小写字母
     * @return 转换后的byte数组，无效输入返回空数组
     */
    public static byte[] hexToBytes(String hexString) {
        // 处理空值或空字符串
        if (hexString == null || hexString.trim().isEmpty()) {
            return new byte[0];
        }

        // 去除空格并转为小写
        String hex = hexString.trim().replaceAll("\\s+", "").toLowerCase(Locale.ROOT);
        int length = hex.length();

        // 十六进制字符串长度必须为偶数
        if (length % 2 != 0) {
            throw new IllegalArgumentException("Invalid hex string: length must be even");
        }

        byte[] bytes = new byte[length / 2];
        for (int i = 0; i < length; i += 2) {
            // 每两个字符转换为一个byte
            int high = hexToInt(hex.charAt(i));
            int low = hexToInt(hex.charAt(i + 1));
            bytes[i / 2] = (byte) ((high << 4) | low);
        }

        return bytes;
    }

    /**
     * 将十六进制字符转换为对应的整数
     *
     * @param c 十六进制字符（0-9, a-f, A-F）
     * @return 对应的整数（0-15）
     */
    private static int hexToInt(char c) {
        if (c >= '0' && c <= '9') {
            return c - '0';
        }
        if (c >= 'a' && c <= 'f') {
            return 10 + (c - 'a');
        }
        if (c >= 'A' && c <= 'F') {
            return 10 + (c - 'A');
        }
        throw new IllegalArgumentException("Invalid hex character: " + c);
    }
}
